    ///
    /// 给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
    ///*
    /// 请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
    ///
    /// 注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。
     ///
     


     /**
     * 相对来说，这个算法比把第二个数组合并到第一个数组上面，然后在排序效率要高些，因为已经是有序的，直接比较进行放置到一个新的数组上
     * 缺点也是这点，需要创建一个新的数组，占用了一个新的空间，后面会写一个merge2方法，来采用尾插，只用使用第一个数组的空间
     * @param nums1
     * @param m
     * @param nums2
     * @param n
     */
    fn merge(nums1:&mut Vec<i32>, m :i32, nums2:Vec<i32>, n :i32) {
        if n<1 {
            return;
        }

        let mut final_arrry= Vec::<i32>::new();
        let mut mi = 0_usize;
        let mut ni = 0_usize;
        while mi <m as usize || ni < n as usize {
            if mi>=m as usize {
                final_arrry.push(*nums2.get(ni).unwrap());
                ni += 1;
            } else if ni >= n as usize {
                final_arrry.push(*nums1.get(mi).unwrap());
                mi += 1;
            } else if nums1.get(mi)<= nums2.get(ni) {
                final_arrry.push(*nums1.get(mi).unwrap());
                mi += 1;
            } else  {
                final_arrry.push(*nums2.get(ni).unwrap());
                ni += 1;
            }
        }
        for (i, item) in final_arrry.iter().enumerate()  {
            nums1[i] = *item;
        }
    }

    /**
     * 和merge方法总体类似，merge是先找最小的值，放入到一个新的数组，我们可以知道第一个数组的后面空间是空的，我们可以有限
     * 查询最大的值放在后面，也可以不用担心num1的值被覆盖掉
     * @param nums1
     * @param m
     * @param nums2
     * @param n
     */
    fn merge2(nums1:&mut Vec<i32>, m :i32, nums2:Vec<i32>, n :i32) {
        if n<1 {
            return;
        }

        let mut mi = (m -1) as isize;
        let mut ni = (n-1) as isize;
        // let mut final_i = (m+n-1) as usize;
        while mi >=0 || ni >=0 {
            let final_i = (mi+ni+1) as usize;
            if mi < 0 {
                nums1[final_i] = *nums2.get(ni as usize).unwrap();
                ni -= 1;
            } else if ni < 0 {
                nums1[final_i] = *nums1.get(mi as usize).unwrap();
                mi -= 1;
            } else if nums1.get(mi as usize)<= nums2.get(ni as usize) {
                nums1[final_i] = *nums2.get(ni as usize).unwrap();
                ni -= 1;
            } else  {
                nums1[final_i] = *nums1.get(mi as usize).unwrap();
                mi -= 1;
            }
        }
    }

    #[cfg(test)]
    mod tests {
        use std::vec;

        use super::*;
    
        #[test]
        fn merge_test1() {
            let mut nums1 = vec![4, 5, 6, 0, 0, 0];
            let nums2 = vec![1,2,3];
            merge(&mut nums1, 3, nums2, 3);
            println!("{:?}", nums1);
        }

        #[test]
        fn merge_test2() {
            let mut nums1 = vec![1, 2, 3, 0, 0, 0];
            let nums2 = vec![2, 5, 6];
            merge(&mut nums1, 3, nums2, 3);
            println!("{:?}", nums1);
        }

        #[test]
        fn merge_test3() {
            let mut nums1 = vec![4, 5, 6, 0, 0, 0];
            let nums2 = vec![1,2,3];
            merge2(&mut nums1, 3, nums2, 3);
            println!("{:?}", nums1);
        }

        #[test]
        fn merge_test4() {
            let mut nums1 = vec![1, 2, 3, 0, 0, 0];
            let nums2 = vec![2, 5, 6];
            merge2(&mut nums1, 3, nums2, 3);
            println!("{:?}", nums1);
        }
    }